Python资源管理：上下文管理器最佳实践

            with open('my_file.txt', 'r') as f:
    content = f.read()
    print(content)

# The file is automatically closed when the 'with' block exits
            

              
                Copy
              
            
          

            try:
    with open('data.csv', 'r', encoding='utf-8') as file:
        for line in file:
            print(line.strip())
except FileNotFoundError:
    print("Error: The file 'data.csv' was not found.")
except UnicodeDecodeError:
    print("Error: Could not decode the file using UTF-8 encoding. Try a different encoding.")
            

              
                Copy
              
            
          

            import sqlite3

class DatabaseConnection:
    def __init__(self, db_name):
        self.db_name = db_name
        self.conn = None  # Initialize the connection attribute

    def __enter__(self):
        self.conn = sqlite3.connect(self.db_name)
        return self.conn

    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type:
            self.conn.rollback()
        else:
            self.conn.commit()
        self.conn.close()

with DatabaseConnection('mydatabase.db') as conn:
    cursor = conn.cursor()
    cursor.execute('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, country TEXT)')
    cursor.execute('INSERT INTO users (name, country) VALUES (?, ?)', ('Alice', 'USA'))
    cursor.execute('INSERT INTO users (name, country) VALUES (?, ?)', ('Bob', 'Germany'))

# Connection is automatically closed and changes are committed or rolled back
            

              
                Copy
              
            
          

            from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# Replace with your actual database connection string
db_url = 'sqlite:///mydatabase.db'

engine = create_engine(db_url, pool_size=5, max_overflow=10) # Enable connection pooling

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    country = Column(String)

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)

class SessionContextManager:
    def __enter__(self):
        self.session = Session()
        return self.session

    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type:
            self.session.rollback()
        else:
            self.session.commit()
        self.session.close()

with SessionContextManager() as session:
    new_user = User(name='Carlos', country='Spain')
    session.add(new_user)

# Session is automatically committed/rolled back and closed
            

              
                Copy
              
            
          

            import socket

class SocketContext:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.socket = None

    def __enter__(self):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.connect((self.host, self.port))
        return self.socket

    def __exit__(self, exc_type, exc_value, traceback):
        self.socket.close()

with SocketContext('example.com', 80) as sock:
    sock.sendall(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
    response = sock.recv(4096)
    print(response.decode('utf-8'))

# Socket is automatically closed
            

              
                Copy
              
            
          

            import socket

class SocketContext:
    def __init__(self, host, port, timeout=5):
        self.host = host
        self.port = port
        self.timeout = timeout
        self.socket = None

    def __enter__(self):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.settimeout(self.timeout)
        try:
            self.socket.connect((self.host, self.port))
        except socket.timeout:
            raise TimeoutError(f"Connection to {self.host}:{self.port} timed out")
        except socket.error as e:
            raise ConnectionError(f"Failed to connect to {self.host}:{self.port}: {e}")
        return self.socket

    def __exit__(self, exc_type, exc_value, traceback):
        if self.socket:
            self.socket.close()

try:
    with SocketContext('example.com', 80, timeout=2) as sock:
        sock.sendall(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
        response = sock.recv(4096)
        print(response.decode('utf-8'))
except (TimeoutError, ConnectionError) as e:
    print(f"Error: {e}")

# Socket is automatically closed, even if errors occur
            

              
                Copy
              
            
          

            import tempfile
import shutil
import os

class TemporaryDirectory:
    def __enter__(self):
        self.dirname = tempfile.mkdtemp()
        return self.dirname

    def __exit__(self, exc_type, exc_value, traceback):
        shutil.rmtree(self.dirname)

with TemporaryDirectory() as tmpdir:
    # Create a file inside the temporary directory
    with open(os.path.join(tmpdir, 'temp_file.txt'), 'w') as f:
        f.write('This is a temporary file.')
    print(f"Temporary directory created: {tmpdir}")

# The temporary directory is automatically deleted when the 'with' block exits
            

              
                Copy
              
            
          

            import contextlib
import os

@contextlib.contextmanager
def change_directory(new_path):
    current_path = os.getcwd()
    try:
        os.chdir(new_path)
        yield
    finally:
        os.chdir(current_path)

with change_directory('/tmp'):
    print(f"Current directory: {os.getcwd()}")

print(f"Current directory: {os.getcwd()}") # Back to original directory
            

              
                Copy
              
            
          

            with open('file1.txt', 'r') as f1, open('file2.txt', 'w') as f2:
    content = f1.read()
    f2.write(content)

# Both files are automatically closed
            

              
                Copy